home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / mint / bed02 / missing.c < prev    next >
C/C++ Source or Header  |  1993-08-15  |  9KB  |  350 lines
  1. /* this file contains functions missing on some libraries
  2.    adjust to your computer taste.
  3.    most of them are taken from the GNU C libraries
  4. */
  5.  
  6. /* Copyright (C) 1991 Free Software Foundation, Inc.
  7. This file is part of the GNU C Library.
  8.  
  9. The GNU C Library is free software; you can redistribute it and/or
  10. modify it under the terms of the GNU Library General Public License as
  11. published by the Free Software Foundation; either version 2 of the
  12. License, or (at your option) any later version.
  13.  
  14. The GNU C Library is distributed in the hope that it will be useful,
  15. but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17. Library General Public License for more details.
  18.  
  19. You should have received a copy of the GNU Library General Public
  20. License along with the GNU C Library; see the file COPYING.LIB.  If
  21. not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  22. Cambridge, MA 02139, USA.  */
  23.  
  24. #include <ctype.h>
  25. #include <limits.h>
  26. #include <stddef.h>
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include <time.h>
  31.  
  32. #define CONST
  33.  
  34. /* Used by strftime, asctime.  */
  35. struct time_info
  36.   {
  37.     char *abbrev_wkday[7];    /* Short weekday names.  */
  38.     char *full_wkday[7];    /* Full weekday names.  */
  39.     char *abbrev_month[12];    /* Short month names.  */
  40.     char *full_month[12];    /* Full month names.  */
  41.     char *ampm[2];        /* "AM" and "PM" strings.  */
  42.  
  43.     char *date_time;        /* Appropriate date and time format.  */
  44.     char *date;            /* Appropriate date format.  */
  45.     char *time;            /* Appropriate time format.  */
  46.  
  47.     char *ut0;            /* Name for GMT.  */
  48.     char *tz;            /* Default TZ value.  */
  49.   };
  50.  
  51. struct time_info __time_C =
  52.   {
  53.     { 
  54. (char *) "Sun", (char *) "Mon", (char *) "Tue", (char *) "Wed", (char *) "Thu", (char *) "Fri", (char *) "Sat",  },
  55.  
  56.     { 
  57. (char *) "Sunday", (char *) "Monday", (char *) "Tuesday", (char *) "Wednesday", (char *) "Thursday", (char *) "Friday", (char *) "Saturday",  },
  58.     { 
  59. (char *) "Jan", (char *) "Feb", (char *) "Mar", (char *) "Apr", (char *) "May", (char *) "Jun", (char *) "Jul", (char *) "Aug", (char *) "Sep", (char *) "Oct", (char *) "Nov", (char *) "Dec",  },
  60.     { 
  61. (char *) "January", (char *) "February", (char *) "March", (char *) "April", (char *) "May", (char *) "June", (char *) "July", (char *) "August", (char *) "September", (char *) "October", (char *) "November", (char *) "December",  },
  62.     { (char *) "AM", (char *) "PM" },
  63.     (char *) "%a %b %d %H:%M:%S %Y", (char *) "%m/%d/%y", (char *) "%H:%M:%S",
  64.     (char *) "GMT", (char *) ""
  65.   };
  66.  
  67. struct time_info *_time_info = &__time_C;
  68.  
  69. #define    add(n, f)                                  \
  70.   do                                          \
  71.     {                                          \
  72.       i += (n);                                      \
  73.       if (i >= maxsize)                                  \
  74.     return 0;                                  \
  75.       else                                      \
  76.     if (p != NULL)                                  \
  77.       {                                      \
  78.         f;                                      \
  79.         p += (n);                                  \
  80.       }                                      \
  81.     } while (0)
  82. #define    cpy(n, s)    add((n), memcpy (p, (s), (n)))
  83. #define    fmt(n, args)    add((n), sprintf args)
  84.  
  85. /* Return the week in the year specified by TP,
  86.    with weeks starting on STARTING_DAY.  */
  87. #ifdef    __GNUC__
  88. inline
  89. #endif
  90. static unsigned int week(struct tm *tp, int starting_day)
  91. {
  92.   int wday, dl;
  93.  
  94.   wday = tp->tm_wday - starting_day;
  95.   if (wday < 0)
  96.     wday += 7;
  97.  
  98.   /* Set DL to the day in the year of the last day of the week previous to the
  99.      one containing the day specified in TP.  If DL is negative or zero, the
  100.      day specified in TP is in the first week of the year.  Otherwise,
  101.      calculate the number of complete weeks before our week (DL / 7) and
  102.      add any partial week at the start of the year (DL % 7).  */
  103.   dl = tp->tm_yday - wday;
  104.   return dl <= 0 ? 0 : ((dl / 7) + ((dl % 7) == 0 ? 0 : 1));
  105. }
  106.  
  107.  
  108. /* Write information from TP into S according to the format
  109.    string FORMAT, writing no more that MAXSIZE characters
  110.    (including the terminating '\0') and returning number of
  111.    characters written.  If S is NULL, nothing will be written
  112.    anywhere, so to determine how many characters would be
  113.    written, use NULL for S and (size_t) UINT_MAX for MAXSIZE.  */
  114. size_t strftime (char *s, size_t maxsize, char *format, struct tm *tp)
  115. {
  116.   CONST char *CONST a_wkday = _time_info->abbrev_wkday[tp->tm_wday];
  117.   CONST char *CONST f_wkday = _time_info->full_wkday[tp->tm_wday];
  118.   CONST char *CONST a_month = _time_info->abbrev_month[tp->tm_mon];
  119.   CONST char *CONST f_month = _time_info->full_month[tp->tm_mon];
  120.   size_t aw_len = strlen(a_wkday);
  121.   size_t am_len = strlen(a_month);
  122.   size_t wkday_len = strlen(f_wkday);
  123.   size_t month_len = strlen(f_month);
  124.   int hour12 = tp->tm_hour;
  125.   CONST char *CONST ampm = _time_info->ampm[hour12 >= 12];
  126.   size_t ap_len = strlen(ampm);
  127.   CONST unsigned int y_week0 = week(tp, 0);
  128.   CONST unsigned int y_week1 = week(tp, 1);
  129.   CONST char *zone;
  130.   size_t zonelen;
  131.   register size_t i = 0;
  132.   register char *p = s;
  133.   register CONST char *f;
  134.  
  135.   if (tp->tm_isdst < 0)
  136.     {
  137.       zone = "";
  138.       zonelen = 0;
  139.     }
  140.   else
  141.     {
  142.       zone = "GMT"; /* __tzname[tp->tm_isdst]; */
  143.       zonelen = strlen(zone);
  144.     }
  145.  
  146.   if (hour12 > 12)
  147.     hour12 -= 12;
  148.   else
  149.     if (hour12 == 0) hour12 = 12;
  150.  
  151.   for (f = format; *f != '\0'; ++f)
  152.     {
  153.       CONST char *subfmt;
  154.  
  155.       if (!isascii(*f))
  156.     {
  157.       /* Non-ASCII, may be a multibyte.  */
  158.       int len = mblen(f, strlen(f));
  159.       if (len > 0)
  160.         {
  161.           cpy(len, f);
  162.           continue;
  163.         }
  164.     }
  165.  
  166.       if (*f != '%')
  167.     {
  168.       add(1, *p = *f);
  169.       continue;
  170.     }
  171.  
  172.       ++f;
  173.       switch (*f)
  174.     {
  175.     case '\0':
  176.     case '%':
  177.       add(1, *p = *f);
  178.       break;
  179.     case 'n':        /* GNU extension.  */
  180.       add (1, *p = '\n');
  181.       break;
  182.     case 't':        /* GNU extenstion.  */
  183.       add (1, *p = '\t');
  184.       break;
  185.  
  186.     case 'a':
  187.       cpy(aw_len, a_wkday);
  188.       break;
  189.     case 'A':
  190.       cpy(wkday_len, f_wkday);
  191.       break;
  192.     case 'b':
  193.       cpy(am_len, a_month);
  194.       break;
  195.     case 'B':
  196.       cpy(month_len, f_month);
  197.       break;
  198.     case 'c':
  199.       subfmt = _time_info->date_time;
  200.     subformat:;
  201.       {
  202.         size_t len = strftime(p, maxsize - i, subfmt, tp);
  203.         add(len, );
  204.       }
  205.       break;
  206.     case 'd':
  207.       fmt(2, (p, "%2.2d", tp->tm_mday));
  208.       break;
  209.     case 'H':
  210.       fmt(2, (p, "%2.2d", tp->tm_hour));
  211.       break;
  212.     case 'I':
  213.       fmt(2, (p, "%2.2d", hour12));
  214.       break;
  215.     case 'j':
  216.       fmt(3, (p, "%3.3d", tp->tm_yday));
  217.       break;
  218.     case 'm':
  219.       fmt(2, (p, "%3.2d", tp->tm_mon + 1));
  220.       break;
  221.     case 'M':
  222.       fmt(2, (p, "%2.2d", tp->tm_min));
  223.       break;
  224.     case 'p':
  225.       cpy(ap_len, ampm);
  226.       break;
  227.     case 'S':
  228.       fmt(2, (p, "%2.2d", tp->tm_sec));
  229.       break;
  230.     case 'U':
  231.       fmt(2, (p, "%2.2u", y_week0));
  232.       break;
  233.     case 'w':
  234.       fmt(2, (p, "%2.2d", tp->tm_wday));
  235.       break;
  236.     case 'W':
  237.       fmt(2, (p, "%2.2u", y_week1));
  238.       break;
  239.     case 'x':
  240.       subfmt = _time_info->date;
  241.       goto subformat;
  242.     case 'X':
  243.       subfmt = _time_info->time;
  244.       goto subformat;
  245.     case 'y':
  246.       fmt(2, (p, "%2.2d", tp->tm_year));
  247.       break;
  248.     case 'Y':
  249.       fmt(4, (p, "%4.4d", 1900 + tp->tm_year));
  250.       break;
  251.     case 'Z':
  252.       cpy(zonelen, zone);
  253.       break;
  254.  
  255.       /* GNU extensions.  */
  256.     case 'r':
  257.       subfmt = "%I:%M:%S %p";
  258.       goto subformat;
  259.     case 'R':
  260.       subfmt = "%H:%M";
  261.       goto subformat;
  262.     case 'T':
  263.       subfmt = "%H:%M:%S";
  264.       goto subformat;
  265.     case 'D':
  266.       subfmt = "%m/%d/%y";
  267.       goto subformat;
  268.  
  269.     case 'e':        /* %d, but blank-padded.  */
  270.       /* XXX */
  271.       break;
  272.  
  273.     default:
  274.       /* Bad format.  */
  275.       break;
  276.     }
  277.     }
  278.  
  279.   if (p != NULL)
  280.     *p = '\0';
  281.   return(i);
  282. }
  283.  
  284. #include <stddef.h>
  285. #include <string.h>
  286.  
  287. #define CONST
  288.  
  289. /* Return the first ocurrence of NEEDLE in HAYSTACK.  */
  290. char *strstr (char *haystack, char *needle)
  291. {
  292.   register CONST char *CONST needle_end = strchr(needle, '\0');
  293.   register CONST char *CONST haystack_end = strchr(haystack, '\0');
  294.   register CONST size_t needle_len = needle_end - needle;
  295.   register CONST size_t needle_last = needle_len - 1;
  296.   register CONST char *begin;
  297.  
  298.   if (needle_len == 0)
  299.     return (char *) haystack_end;
  300.   if ((size_t) (haystack_end - haystack) < needle_len)
  301.     return NULL;
  302.  
  303.   for (begin = &haystack[needle_last]; begin < haystack_end; ++begin)
  304.     {
  305.       register CONST char *n = &needle[needle_last];
  306.       register CONST char *h = begin;
  307.       do
  308.     if (*h != *n)
  309.       goto loop;
  310.       while (--n >= needle && --h >= haystack);
  311.  
  312.       return (char *) h;
  313.     loop:;
  314.     }
  315.  
  316.   return NULL;
  317. }
  318.  
  319. char *strdup (s)
  320. char *s;
  321. {
  322.     char *t;
  323.     t=malloc (strlen(s)+1);
  324.     if (t != NULL)
  325.         strcpy (t, s);
  326.     return t;
  327. }
  328.  
  329. char *strupr (s)
  330. char *s;
  331. {
  332.     char *old=s;
  333.     while (*s) {
  334.         *s = toupper (*s);
  335.         s++;
  336.     }
  337.     return old;
  338. }
  339.  
  340. char *strlwr (s)
  341. char *s;
  342. {
  343.     char *old=s;
  344.     while (*s) {
  345.         *s = tolower (*s);
  346.         s++;
  347.     }
  348.     return old;
  349. }
  350.